
package capa_logica;

import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Set;
import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.websocket.EncodeException;
import javax.websocket.OnClose;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint(value="/wsjuego", encoders = {WSTransporteCodificador.class}, decoders =
        {WSTransporteDecodificador.class})

// Esta clase controla las acciones y manejas Jsons
public class WSJuego 
{

    //Mapa de conexiones abiertas. <JugadorA, JugadorB><JugadorB, JugadorA>
 
    private static HashMap<String, Session> parDeConexiones = new HashMap<String, Session>(); 
    
    //Peers que no tienen un rival asignado.

    private static LinkedList<Session> peersQueCrearonPartida = new LinkedList<Session>();

    
    //Este mapa se usa para mantener control de la partida asociada a la session.
    private static HashMap<String, Partida> mapaIdSession_Partida = new HashMap<String, Partida>();
    
    //Usuarios que están en el servidor.
    private static HashMap<String, Session> mapaUsuariosConectados = new HashMap<String, Session>();

    //Usuarios que crearon una nueva partida. <Id de la session, Rol(jugador1, jugador2)>
    private static HashMap<String, String> mapaUsuariosPartidaNueva = new HashMap<String, String>();
    
    //Mapa con todos los usuarios y roles. Se usa solo a la hora de cerrar conexión.
    private static HashMap<String, String> mapaUsuariosTotales = new HashMap<String, String>();   
    
    //Usuarios que cargar una nueva partida y eligen rol <Id de la session, Partida>
    //No hay ninguna partida con este número disponible para unirse.
    private static HashMap<String, Partida> mapaPartidasCargadasEnEspera = new HashMap<String, Partida>();
    
     private static LinkedList<Integer> partidasCargadasEnEspera = new LinkedList<Integer>();
     
     //Este mapa tiene el id de una partida traida de BD y la session del que espera por un rival.
     private static HashMap<Integer, Session> mapaSessionesYPartidasCargadas = new HashMap<Integer, Session>();
    
    
    


    @OnMessage
    public void recibeJson(WSTransporte wst, Session session) throws IOException, EncodeException, InterruptedException 
    {
        String accion = wst.getJson().getString("accion");
        switch(accion)
        {
            case "mover":
                /* Del lado del cliente se captura el evento mover
                Obtengo: piloto o tanque1 o tanque2 */
                String actor = wst.getJson().getString("actor");
                String tecla = wst.getJson().getString("tecla");

                
                switch (actor)
                {
                    case "piloto":
                        /* Del lado del cliente se captura que es el piloto

                        quien se movio
                        Pido la partida del piloto. */
                        Partida partidaPiloto = mapaIdSession_Partida.get(session.getId());
                        
                         /* Llamo a la funcion que mueve el piloto */
                        JsonObject jsonJugador1 = partidaPiloto.moverPiloto(tecla);
                        JsonObject jsonJugador1Iluminar = partidaPiloto.IluminarPiloto();
                        
                        /* Envio Json al cliente del lado del jugador1*/
                        session.getBasicRemote().sendObject(jsonJugador1);
                        session.getBasicRemote().sendObject(jsonJugador1Iluminar);
                        
                        //Pido el rival
                        Session rival = parDeConexiones.get(session.getId());
                       
                        /*Actualizo mapa de partidas. Ver si se puede hacer más

                        eficiente.*/
                        mapaIdSession_Partida.put(session.getId(), partidaPiloto);
                        mapaIdSession_Partida.put(rival.getId(), partidaPiloto);
                        
                        /* Envio Json al cliente del lado del jugador2*/
                        rival.getBasicRemote().sendObject(jsonJugador1);
                        break;
                    
                    case "tanque1":
                        /* Del lado del cliente se captura que es el tanque1
                        quien se movio */
                        Partida partidaTanque = mapaIdSession_Partida.get(session.getId());
                        Partida partidaAvion = 
                        mapaIdSession_Partida.get(parDeConexiones.get(session.getId()).getId());
                        /*Si el tanque no fue destruido*/
                        if(partidaTanque.getTanque1().getEnergia() > 0)
                        {
                            /* Llamo a la funcion que mueve el tangue */
                            JsonObject jsonJugador2 = partidaTanque.moverTanque(tecla, 1);
                            JsonObject jsonIluminarTanque1 = partidaTanque.iluminarTanques();

                            /* Mando el JSON al jugador que provoco el evento */
                            session.getBasicRemote().sendObject(jsonJugador2);
                            session.getBasicRemote().sendObject(jsonIluminarTanque1);
                            Session rival1 = parDeConexiones.get(session.getId());
                        
                            //Actualizo mapa de partidas. Ver si se puede hacer más
                            //eficiente.
                            mapaIdSession_Partida.put(session.getId(), partidaTanque);
                            mapaIdSession_Partida.put(rival1.getId(), partidaTanque);

                            /* Mando el JSON al rival */
                            rival1.getBasicRemote().sendObject(jsonJugador2);

                            //Si estamos mostrando la vista lateral se debe ordenar mover el tanque
                            if(partidaAvion.getAvion().lateral)
                            {
                                JsonObject jsonMoverTanqueLat = partidaTanque.JsonMoverTanqueLateral
                                (tecla, 1);
                                session.getBasicRemote().sendObject(jsonMoverTanqueLat);
                                rival1.getBasicRemote().sendObject(jsonMoverTanqueLat);
                            }
                        }
                        break;
                        
                    case "tanque2":
                        /* Del lado del cliente se captura que es el tanque2
                        quien se movio */
                        Partida partidaTanque2 = mapaIdSession_Partida.get(session.getId());
                        Partida partidaAvion2 = 
                        mapaIdSession_Partida.get(parDeConexiones.get(session.getId()).getId());
                        /*Si el tanque no fue destruido*/
                        if(partidaTanque2.getTanque2().getEnergia() > 0)
                        {
                            JsonObject jsonJugador3 = partidaTanque2.moverTanque(tecla, 2);
                            JsonObject jsonIluminarTanque2 = partidaTanque2.iluminarTanques();
                            session.getBasicRemote().sendObject(jsonJugador3);
                            session.getBasicRemote().sendObject(jsonIluminarTanque2);
                            Session rival2 = parDeConexiones.get(session.getId());

                            //Actualizo mapa de partidas. Ver si se puede hacer más
                            //eficiente.
                            mapaIdSession_Partida.put(session.getId(), partidaTanque2);
                            mapaIdSession_Partida.put(rival2.getId(), partidaTanque2);
                            rival2.getBasicRemote().sendObject(jsonJugador3);


                            if(partidaAvion2.getAvion().lateral)
                            {
                                JsonObject jsonMoverTanqueLat = partidaTanque2.JsonMoverTanqueLateral
                                (tecla, 2);
                                session.getBasicRemote().sendObject(jsonMoverTanqueLat);
                                rival2.getBasicRemote().sendObject(jsonMoverTanqueLat);
                            }
                        }
                        break;
                        
                    case "drone":
                        /* Pido la partida del jugador1 y del jugador2 */
                        Partida partidaPilotoDrone = mapaIdSession_Partida.get(session.getId());
                        Partida partidaTanqueDrone = 
                            mapaIdSession_Partida.get(parDeConexiones.get(session.getId()).getId());
                        
                        /* Obtengo la session del jugador2 */
                        Session rival4 = parDeConexiones.get(session.getId());


                        
                        try
                        {  
                            partidaPilotoDrone.getDrone().jugador1 = session;
                            partidaPilotoDrone.getDrone().jugador2 = rival4;
                            partidaTanqueDrone.setDrone(partidaPilotoDrone.getDrone());
                            partidaPilotoDrone.getDrone().LanzarDrone();
                        }
                        catch(Exception ex)
                        {
                            System.out.println(ex);
                        }
                        break;
                }
                break;
                
            case "disparar" :
                String actor1 = wst.getJson().getString("actor");
                
                switch (actor1) 
                {
                    case "tanque1":
                        Partida partidaTanque = mapaIdSession_Partida.get(session.getId());
                        Session rival4 = parDeConexiones.get(session.getId());
                        Tanque t1 = partidaTanque.getTanque1();
                        t1.jugador2 = session;
                        t1.jugador1 = rival4;
                        Proyectil proy = t1.disparar();
                        if (proy.disparoProyectil())
                        {
                            if (proy.objetivoAlcanzado == 'p')
                            {
                                JsonObjectBuilder buildJson3 = 
                                        Json.createObjectBuilder().add("orden", "eliminar");
                                buildJson3 = buildJson3.add("actor", "piloto");
                                buildJson3 = 
                                        buildJson3.add("posicionObjetivoX", proy.posicionObjetivoX);
                                buildJson3 = 
                                        buildJson3.add("posicionObjetivoY", proy.posicionObjetivoY);
                                JsonObject value3 = buildJson3.build();
                                partidaTanque.MatarDrone();
                                session.getBasicRemote().sendObject(value3);
                                parDeConexiones.get(
                                        session.getId()).getBasicRemote().sendObject(value3);
                                buildJson3 = 
                                        Json.createObjectBuilder().add("orden", "finalizarJuego");
                                buildJson3 = buildJson3.add("jugadorGanador", "empate");
                                value3 = buildJson3.build();
                                session.getBasicRemote().sendObject(value3);
                                parDeConexiones.get(
                                        session.getId()).getBasicRemote().sendObject(value3);

                            }
                            
                            if (proy.objetivoAlcanzado == 't')
                            { 
                                Partida partida = mapaIdSession_Partida.get(session.getId());
                                Coordenada c =
                                        partida.romperObstaculo(
                                                proy.posicionObjetivoX, proy.posicionObjetivoY);

                                JsonObjectBuilder buildJson3 =
                                        Json.createObjectBuilder().add("orden", "romper");
                                buildJson3 = buildJson3.add("posicionObjetivoX", c.getX());
                                buildJson3 = buildJson3.add("posicionObjetivoY", c.getY());
                                JsonObject value3 = buildJson3.build();
                                session.getBasicRemote().sendObject(value3);
                                parDeConexiones.get(
                                        session.getId()).getBasicRemote().sendObject(value3);
                            }
                        }
                        break;
                        
                    case "tanque2":
                        Partida partidaTanque2 = mapaIdSession_Partida.get(session.getId());
                        Session rival5 = parDeConexiones.get(session.getId()); 
                        Tanque t2 = partidaTanque2.getTanque2();
                        t2.jugador2 = session;
                        t2.jugador1 = rival5;
                        Proyectil proy2 = t2.disparar();
                        if (proy2.disparoProyectil())
                        {
                            if (proy2.objetivoAlcanzado == 'p')
                            {
                                JsonObjectBuilder buildJson4 = 
                                        Json.createObjectBuilder().add("orden", "eliminar");

                                buildJson4 = buildJson4.add("actor", "piloto");
                                buildJson4 = buildJson4.add(
                                        "posicionObjetivoX", proy2.posicionObjetivoX);
                                buildJson4 = buildJson4.add(
                                        "posicionObjetivoY", proy2.posicionObjetivoY);
                                JsonObject value4 = buildJson4.build();
                                partidaTanque2.MatarDrone();
                                session.getBasicRemote().sendObject(value4);
                                parDeConexiones.get(
                                        session.getId()).getBasicRemote().sendObject(value4);

                                buildJson4 = Json.createObjectBuilder().add(
                                        "orden", "finalizarJuego");
                                buildJson4 = buildJson4.add(
                                        "jugadorGanador", "empate");
                                value4 = buildJson4.build();
                                session.getBasicRemote().sendObject(value4);
                                parDeConexiones.get(
                                        session.getId()).getBasicRemote().sendObject(value4);

                            }
                            
                            if (proy2.objetivoAlcanzado == 't')
                            { 
                                Partida partida = mapaIdSession_Partida.get(session.getId());
                                Coordenada c = partida.romperObstaculo(
                                        proy2.posicionObjetivoX, proy2.posicionObjetivoY);
                                JsonObjectBuilder buildJson3 = 
                                        Json.createObjectBuilder().add("orden", "romper");

                                buildJson3 = buildJson3.add("posicionObjetivoX", c.getX());
                                buildJson3 = buildJson3.add("posicionObjetivoY", c.getY());
                                JsonObject value3 = buildJson3.build();
                                session.getBasicRemote().sendObject(value3);
                                parDeConexiones.get(
                                        session.getId()).getBasicRemote().sendObject(value3);

                            }
                        }
                        break;
                }
            break; //Termina disparar.
                
               case "click":

                int clickX = wst.getJson().getInt("x");
                int clickY = wst.getJson().getInt("y");
                Partida partidaPilotoAvion = mapaIdSession_Partida.get(session.getId());
                Partida partidaTanqueAvion = mapaIdSession_Partida.get(parDeConexiones.get(session.getId()).getId());
                Session rival3 = parDeConexiones.get(session.getId());
                try
                {
                    partidaPilotoAvion.getAvion().jugador1 = session;
                    partidaPilotoAvion.getAvion().jugador2 = rival3;
                    partidaTanqueAvion.setAvion(partidaPilotoAvion.getAvion());
                    partidaPilotoAvion.getAvion().setClickX(clickX);
                    partidaPilotoAvion.getAvion().setClickY(clickY);
                
                    if(partidaPilotoAvion.getAvion().isLateral())
                    {
                        if(((partidaPilotoAvion.getAvion().getBombas()) > 0) && !partidaPilotoAvion.getAvion().isLanzoBomba())
                        {
                            partidaPilotoAvion.getAvion().setLanzoBomba(true);
                            partidaPilotoAvion.getAvion().setBombas(
                                (partidaPilotoAvion.getAvion().getBombas()) - 1);
                        }
                    }
                    else
                    {
                        partidaPilotoAvion.getAvion().setTanque1(partidaTanqueAvion.getTanque1());
                        partidaPilotoAvion.getAvion().setTanque2(partidaTanqueAvion.getTanque2());
                        partidaPilotoAvion.getAvion().LanzarAvion(false);
                    }

                }
                catch(Exception ex)
                {
                    System.out.println(ex);
                }

                break;
                
            case "guardar" :

                Partida p = mapaIdSession_Partida.get(session.getId());
                JsonObjectBuilder construirJsonG = Json.createObjectBuilder().add("orden","partidaGuardada");
                construirJsonG = construirJsonG.add("numeroPartida", p.guardarPartida());
                JsonObject jsonGuardar = construirJsonG.build();
                if (parDeConexiones.get(session.getId()) != null){
                //Si tengo rival conectado
                     Session rival = parDeConexiones.get(session.getId());
                     if (session.isOpen()){
                         session.getBasicRemote().sendObject(jsonGuardar);
                     }
                     if (rival.isOpen()){
                         rival.getBasicRemote().sendObject(jsonGuardar);
                     }
                    
                }
                
                break;
                
            case "cargar" :

                Partida pa = mapaIdSession_Partida.get(session.getId());
                
                int idPartida = wst.getJson().getInt("idPartida");
                
                pa.cargarPartida(idPartida);
                JsonObjectBuilder construirJson6 = Json.createObjectBuilder().add("orden","cargar");
                construirJson6 = 
                        construirJson6.add("pilotoX",pa.getPiloto().getPosicionX());
                construirJson6 = 
                        construirJson6.add("pilotoY",pa.getPiloto().getPosicionY());
                construirJson6 = 
                        construirJson6.add("orientacion",pa.getPiloto().getOrientacion());
                construirJson6 = 
                        construirJson6.add("tanque1X",pa.getTanque1().getPosicionX());
                construirJson6 = 
                        construirJson6.add("tanque1Y",pa.getTanque1().getPosicionY());
                construirJson6 = 
                        construirJson6.add("tanque2X",pa.getTanque2().getPosicionX());
                construirJson6 = 
                        construirJson6.add("tanque2Y",pa.getTanque2().getPosicionY());
                construirJson6 = 
                       construirJson6.add("orientacionT1",pa.getTanque1().getOrientacion());
                construirJson6 = 
                       construirJson6.add("orientacionT2",pa.getTanque2().getOrientacion());
                JsonObject jsonPartida = construirJson6.build();


                session.getBasicRemote().sendObject(jsonPartida);
                Session rival5 = parDeConexiones.get(session.getId());


                //Actualizo mapa de partidas.
                mapaIdSession_Partida.put(session.getId(), pa);
                mapaIdSession_Partida.put(rival5.getId(), pa);
                rival5.getBasicRemote().sendObject(jsonPartida);
                break;
                
            case "vistaMatriz":

                Partida part = mapaIdSession_Partida.get(session.getId());
                JsonObject jsonPartida2 = part.vistaRayosX();
                session.getBasicRemote().sendObject(jsonPartida2);
                Session rival6 = parDeConexiones.get(session.getId());
                rival6.getBasicRemote().sendObject(jsonPartida2);
                break;
                
            case "clickDerecho" :
                Partida pP = mapaIdSession_Partida.get(session.getId());
                if (!pP.getAvion().isEnMovimiento()){
                    Partida pT = mapaIdSession_Partida.get(parDeConexiones.get(session.getId()).getId());
                    int clickDerechoX = wst.getJson().getInt("x");
                    int clickDerechoY = wst.getJson().getInt("y");
                    Session rival4 = parDeConexiones.get(session.getId());
                    pP.getAvion().jugador1 = session;
                    pP.getAvion().jugador2 = rival4;
                    pT.setAvion(pP.getAvion());
                    pP.getAvion().setClickX(clickDerechoX);
                    pP.getAvion().setClickY(clickDerechoY);
                    JsonObject json = pP.JsonDibujarVistaLateral(clickDerechoX, clickDerechoY);
                    session.getBasicRemote().sendObject(json);
                    rival4.getBasicRemote().sendObject(json);
                    pP.getAvion().LanzarAvion(true);
                    pP.getAvion().JsonTerminarLateral();
                }
                break;
            
            case "nuevaPartida":
                String rol = wst.getJson().getString("actor");
                mapaUsuariosPartidaNueva.put(session.getId(), rol);
                peersQueCrearonPartida.add(session);
                Set<String> setIdsConectados = mapaUsuariosConectados.keySet();
                mapaUsuariosTotales.put(session.getId(), rol);
                for (String aux : setIdsConectados)
                {
                    if (!mapaUsuariosPartidaNueva.containsKey(aux))
                    {
                        JsonObjectBuilder construirJson = Json.createObjectBuilder().add("orden","habilitoUnirse");
                        JsonObject jsonUnirse = construirJson.build();
                        mapaUsuariosConectados.get(aux).getBasicRemote().sendObject(jsonUnirse);
                    }
                }
                break;
                /* AGREGO I PARA HACER CARGA DE PARTIDA*/
                case "cargarPartidaInicio":
                String s = wst.getJson().getString("idPartida");
                boolean esNumero = true;
                boolean numeroGrande = false;
                if(s.length() > 8)
                {
                    numeroGrande = true;
                }
                try 
                { 
                    Integer.parseInt(s); 
                } 
                catch(NumberFormatException e) 
                { 
                     esNumero = false;
                }
                if(esNumero)
                {
                    int idPartidaInicio = Integer.valueOf(wst.getJson().getString("idPartida"));
                    if (!partidasCargadasEnEspera.contains(idPartidaInicio))
                    {
                        Escenario e = new Escenario(1, "Gramilla");
                        Partida partidaCargar = new Partida(e, null);
                        if (partidaCargar.cargarPartida(idPartidaInicio) && !numeroGrande)
                        {
                             partidasCargadasEnEspera.add(idPartidaInicio);
                             mapaSessionesYPartidasCargadas.put(idPartidaInicio, session);
                             mapaPartidasCargadasEnEspera.put(session.getId(), partidaCargar);
                             //JSON PARA ELEGIR USUARIO
                             JsonObjectBuilder construirJson = Json.createObjectBuilder().add("orden","cargarJugadorElijoRol");
                             JsonObject jsonElijoRol = construirJson.build();
                             session.getBasicRemote().sendObject(jsonElijoRol);

                        }
                        else
                        {
                             JsonObjectBuilder construirJson = Json.createObjectBuilder().add("orden","avisarPartidaNoExiste");
                             JsonObject jsonNoExiste = construirJson.build();
                             session.getBasicRemote().sendObject(jsonNoExiste);
                        } 
                    }
                    else
                    {
                        //Unimos a la partida creada por el rival.
                        //mapaSessionesYPartidasCargadas.remove
                        Session miRival = mapaSessionesYPartidasCargadas.get(idPartidaInicio);
                        Partida partidaRivalCargo = mapaPartidasCargadasEnEspera.remove(miRival.getId());
                        String rolDelRival = "jugador1";
                        if (partidaRivalCargo.jugador1 == null){
                            rolDelRival = "jugador2";
                        }
                        parDeConexiones.put(miRival.getId(), session);
                        parDeConexiones.put(session.getId(), miRival);
                        try
                        {
                            //Escenario e = new Escenario(0, "Desierto", 1245, 700);


                            if ("jugador1".equals(rolDelRival))
                            {
                                partidaRivalCargo.setJugador1(miRival);
                                partidaRivalCargo.setJugador2(session);
                                mapaUsuariosTotales.put(miRival.getId(), "jugador1");
                                mapaUsuariosTotales.put(session.getId(), "jugador2");
                            }

                            else
                            {
                                partidaRivalCargo.setJugador2(miRival);
                                partidaRivalCargo.setJugador1(session);
                                 mapaUsuariosTotales.put(session.getId(), "jugador1");
                                 mapaUsuariosTotales.put(miRival.getId(), "jugador2");
                            }



                            //Cargo el mapa de partidas.

                            mapaIdSession_Partida.put(miRival.getId(), partidaRivalCargo);
                            mapaIdSession_Partida.put(session.getId(), partidaRivalCargo);

                            JsonObject jsonJugador1 = partidaRivalCargo.dibujarEscenario("jugador1");
                            JsonObject jsonJugador2 = partidaRivalCargo.dibujarEscenario("jugador2");
                            JsonObject jsonArboles = partidaRivalCargo.cargarArboles();

                            //Envio Json dependiendo que jugador es cada uno
                            if ("jugador1".equals(rolDelRival))
                            {
                                miRival.getBasicRemote().sendObject(jsonJugador1);
                                miRival.getBasicRemote().sendObject(jsonArboles);
                                session.getBasicRemote().sendObject(jsonJugador2);
                                session.getBasicRemote().sendObject(jsonArboles);
                            }

                            else
                            {
                                miRival.getBasicRemote().sendObject(jsonJugador2);
                                miRival.getBasicRemote().sendObject(jsonArboles);
                                session.getBasicRemote().sendObject(jsonJugador1);
                                session.getBasicRemote().sendObject(jsonArboles);
                            }


                        partidaRivalCargo.comenzarReloj(partidaRivalCargo.getMinutos(), 
                                partidaRivalCargo.getSegundos());

                        }
                        catch(Exception e)
                        {
                            System.out.println(e.toString());
                        }    
                    }
                }
                else
                {
                    JsonObjectBuilder construirJson = Json.createObjectBuilder().add("orden","noIngresoUnNumero");
                    JsonObject jsonNoNumero = construirJson.build();
                    session.getBasicRemote().sendObject(jsonNoNumero);
                }

                break;
                 case "elijoRolCargar" :
                     String rolDelQueCarga = wst.getJson().getString("rol");
                     Partida partidaCargadaParaRol = mapaPartidasCargadasEnEspera.get(session.getId());
                     switch (rolDelQueCarga){
                         case "jugador1":
                             partidaCargadaParaRol.jugador1 = session;
                             partidaCargadaParaRol.jugador2 = null;
                             break;
                         case "jugador2":
                             partidaCargadaParaRol.jugador1 = null;
                             partidaCargadaParaRol.jugador2 = session;
                             break;
                     }
                     mapaPartidasCargadasEnEspera.put(session.getId(), partidaCargadaParaRol);
                     
                break;
                     /* fin AGREGO I PARA HACER CARGA DE PARTIDA*/
            case "unirsePartida":
                Session miRival =  peersQueCrearonPartida.removeFirst();
                String rolDelRival = mapaUsuariosPartidaNueva.remove(miRival.getId());
                
                /*Tengo el mapa que identifica el rival de un determinado
                jugador (session).
                El jugador 1 es miRival y jugador2 peer.*/
                parDeConexiones.put(miRival.getId(), session);
                parDeConexiones.put(session.getId(), miRival);
                
                try
                {
                    
                    Escenario e = new Escenario(1, "Gramilla");
                    Partida partidaNueva = new Partida(e, null);
                    partidaNueva.ocuparMatriz();
                    if ("jugador1".equals(rolDelRival))
                    {
                        partidaNueva.setJugador1(miRival);
                        partidaNueva.setJugador2(session);
                        mapaUsuariosTotales.put(session.getId(), "jugador2");
                    }

                    else
                    {
                        partidaNueva.setJugador2(miRival);
                        partidaNueva.setJugador1(session);
                         mapaUsuariosTotales.put(session.getId(), "jugador1");
                    }
                    


                    //Cargo el mapa de partidas.

                    mapaIdSession_Partida.put(miRival.getId(), partidaNueva);
                    mapaIdSession_Partida.put(session.getId(), partidaNueva);

                    JsonObject jsonJugador1 = partidaNueva.dibujarEscenario("jugador1");
                    JsonObject jsonJugador2 = partidaNueva.dibujarEscenario("jugador2");
                    JsonObject jsonArboles = partidaNueva.cargarArboles();
                    
                    //Envio Json dependiendo que jugador es cada uno
                    if ("jugador1".equals(rolDelRival))
                    {
                        miRival.getBasicRemote().sendObject(jsonJugador1);
                        miRival.getBasicRemote().sendObject(jsonArboles);
                        session.getBasicRemote().sendObject(jsonJugador2);
                        session.getBasicRemote().sendObject(jsonArboles);
                    }

                    else
                    {
                        miRival.getBasicRemote().sendObject(jsonJugador2);
                        miRival.getBasicRemote().sendObject(jsonArboles);
                        session.getBasicRemote().sendObject(jsonJugador1);
                        session.getBasicRemote().sendObject(jsonArboles);
                    }


                    partidaNueva.comenzarReloj();
                    JsonObjectBuilder construirJson2 = Json.createObjectBuilder().add("orden","habilitoAbandonar");
                    JsonObject jsonAbandonar = construirJson2.build();
                    session.getBasicRemote().sendObject(jsonAbandonar);
                    miRival.getBasicRemote().sendObject(jsonAbandonar);
                }
                catch(Exception e)
                {
                    System.out.println(e.toString());
                }
                break;
            case "pausar":
                if (parDeConexiones.get(session.getId()) != null){
                Session rivalPausa = parDeConexiones.get(session.getId());
                JsonObjectBuilder construirJson = Json.createObjectBuilder().add("orden","pausar");
                JsonObject jsonPausar = construirJson.build();
                rivalPausa.getBasicRemote().sendObject(jsonPausar);
                Partida partidaPausa = mapaIdSession_Partida.get(session.getId());
                if (partidaPausa.partidaPausada()){
                    partidaPausa.comenzarReloj();
                }
                else{
                    partidaPausa.pausarReloj();
                }
                }
                break;
















        }        
    }
    
    @OnOpen
    public void onOpen(Session peer) throws IOException, EncodeException 
    {
        //Entra un usuario y lo agrego a esta lista.
        mapaUsuariosConectados.put(peer.getId(), peer);
        
        if (!mapaUsuariosPartidaNueva.isEmpty())

        {    
            JsonObjectBuilder construirJson = 
                    Json.createObjectBuilder().add("orden","habilitoUnirse");
            JsonObject jsonUnirse = construirJson.build();
            peer.getBasicRemote().sendObject(jsonUnirse);

        }
        
                    
    }
        






       @OnClose
    public void onClose(Session peer) throws IOException, EncodeException 
    {
       System.out.println("Conexiones on close: " );
       Session rival = parDeConexiones.get(peer.getId());
       System.out.println("Rival "+parDeConexiones.get(peer.getId()) );

       /* Quito la partida asociada al rival del mapa de partidas */
      System.out.println(mapaIdSession_Partida);
       try{


           if (parDeConexiones.get(peer.getId()) != null){
            System.out.println("Close -1 "+mapaIdSession_Partida.get(parDeConexiones.get(peer.getId())));   
            Partida part1 = mapaIdSession_Partida.remove(peer.getId());
            if (partidasCargadasEnEspera.contains(part1.getIdPartida()))
                partidasCargadasEnEspera.remove(part1.getIdPartida());
            if (mapaPartidasCargadasEnEspera.containsKey(peer.getId()))
                mapaPartidasCargadasEnEspera.remove(peer.getId());
            if (mapaSessionesYPartidasCargadas.containsKey(part1.getIdPartida())){
                mapaSessionesYPartidasCargadas.remove(part1.getIdPartida());
            }
            System.out.println("Close 0");    
            part1.MatarDrone();
            System.out.println("Close 0.1");
       };
       System.out.println("Close 1");

       /* Quito la partida del mapa de partidas */
       mapaIdSession_Partida.remove(peer.getId());
       System.out.println("Close 2");

       /* Elmino al rival del mapa de conexiones */
       if (parDeConexiones.get(peer.getId()) != null){

            parDeConexiones.remove(parDeConexiones.get(peer.getId()));
       }
       System.out.println("Close 3");
       /* Elmino al jugador del mapa de conexiones */
       

       if (peersQueCrearonPartida.contains(peer)){
           peersQueCrearonPartida.remove(peer);
       }
       System.out.println("Close 4");

       if (mapaUsuariosConectados.get(peer.getId())!= null){

           mapaUsuariosConectados.remove(peer.getId());
       }
       System.out.println("Close 5");

       if (mapaUsuariosPartidaNueva.get(peer.getId()) != null){

           mapaUsuariosPartidaNueva.remove(peer.getId());
       }
       System.out.println("Close 6");
       System.out.println(parDeConexiones.get(peer.getId()) != null);

       if (parDeConexiones.get(peer.getId()) != null){
           System.out.println("Cerrando conexiones");

           JsonObjectBuilder buildJson3 = Json.createObjectBuilder().add("orden", "finalizarJuego");
           buildJson3 = buildJson3.add("jugadorGanador", mapaUsuariosTotales.get(rival.getId()));
           JsonObject jsonSend = buildJson3.build();
           if (rival.isOpen()){
           rival.getBasicRemote().sendObject(jsonSend);
           rival.close();
           }
       }
       parDeConexiones.remove(peer.getId());
       }
       catch(Exception ex){
           System.out.println(ex.toString());
       }
    }
}
